package cxydmmszl.chapter08.t122;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.HashSet;

/**
 * <li style="color: red;">Prob</li>
 * 最长的可整合子数组的长度
 * <li style="color: green;">Desc</li>
 * 先给出可整合数组的定义：
 * 如果一个数组在排序之后，每相邻两个数的差的绝对值都为1，
 * 或者该数组长度为1，则该数组为可整合数组。
 * 例如，[5, 3, 4, 6, 2] 排序后为 [2, 3, 4, 5, 6]，
 * 符合每相邻两个数差的绝对值都为1，所以这个数组为可整合数组。<br/>
 * 给定一个数组 arr, 请返回其中最大可整合子数组的长度。
 * 例如，[5, 5, 3, 2, 6, 4, 3] 的最大可整合子数组为 [5, 3, 2, 6, 4]，所以请返回 5。
 * <br/><br/>
 * 数据范围：0 < n <= 100000，0 < arr[i] <= 10^9<br/>
 * 要求：时间复杂度为 O(n^2)，空间复杂度为 O(n)<br/>
 * 进阶：时间复杂度为 O(nlogn)，空间复杂度为 O(n)
 * <br/><br/>注意：本题中子数组的定义是数组中连续的一段区间，
 * 例如 [1,2,3,4,5] 中 [2,3,4] 是子数组，[2,4,5] 和 [1,3] 不是子数组
 * <li style="color: green;">Input</li>
 * 第一行一个整数N，表示数组长度；第二行N个整数，分别表示数组内的元素。
 * <li style="color: green;">Output</li>
 * 输出一个整数，表示最大可整合子数组的长度
 * <li style="color: blue;">Link</li> CD2
 *
 * @author habitplus
 * @since 2021-10-08 15:57
 */
public class Main {
    static final StreamTokenizer st =
            new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static int nextInt() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) st.nval;
    }

    public static void main(String[] args) {
        int n = nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextInt();
        }

        int ans = getLongestIntegerArrLength1(arr);
        System.out.println(ans);
    }

    /*
        O(n^2)
     */
    private static int getLongestIntegerArrLength1(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }

        int n = arr.length;
        int minNum, maxNum;
        HashSet<Integer> set = new HashSet<>();
        int res = 0;
        for (int i = 0; i < n; i++) {
            minNum = Integer.MAX_VALUE;
            maxNum = Integer.MIN_VALUE;
            for (int j = i; j < n; j++) {
                if (set.contains(arr[j])) {
                    break;
                }

                set.add(arr[j]);
                minNum = Math.min(arr[j], minNum);
                maxNum = Math.max(arr[j], maxNum);

                if (j - i == maxNum - minNum) {
                    res = Math.max(res, j - i + 1);
                }
            }
            set.clear();
        }

        return res;
    }
}
